/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.osiris.persistence.controllers.impl;

import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;

import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Restrictions;
import org.osiris.persistence.Relacionrequisito;
import org.osiris.persistence.RelacionrequisitoPK;
import org.osiris.persistence.Requisito;
import org.osiris.persistence.Requisitosdeproyecto;
import org.osiris.persistence.Tiposderelacion;
import org.osiris.persistence.controllers.RelacionRequisitoInterface;
import org.osiris.persistence.controllers.RelacionRequisitoInterface;
import org.osiris.persistence.controllers.exceptions.NonexistentEntityException;
import org.osiris.persistence.controllers.exceptions.PreexistingEntityException;

/**
 *
 * @author amartinez
 */
public class RelacionrequisitoJpaController implements RelacionRequisitoInterface{

	Logger logger=Logger.getLogger(this.getClass());
    public RelacionrequisitoJpaController() {
    	emf = CreadorPU.getEntityManagerFactory();
    }
    private EntityManagerFactory emf = null;

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#getEntityManager()
	 */
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#create(org.osiris.persistence.Relacionrequisito)
	 */
    
    
    @SuppressWarnings("unchecked")
	public List<Relacionrequisito> findDependencias(Long idRequisito){
    	org.hibernate.Session session = (Session)getEntityManager().getDelegate(); 
    	session.beginTransaction();
    	Criteria criteria = session.createCriteria(Relacionrequisito.class);
    	
    	if(idRequisito!=null){
    		Criteria crit2 = criteria.createCriteria("requisito");
    		crit2.add(Restrictions.like("idRequisito",idRequisito));    		
		}		
		
		List <Relacionrequisito> Requisitos = criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY).list();
		
        session.getTransaction().commit();
        logger.info("Devolviendo:"+Requisitos.size()+" encontrados");
        return Requisitos;
    }
    @SuppressWarnings("unchecked")
	public Relacionrequisito findDependencia(Long idRequisito,Long destino){
    	org.hibernate.Session session = (Session)getEntityManager().getDelegate(); 
    	session.beginTransaction();
    	Criteria criteria = session.createCriteria(Relacionrequisito.class);
    	
    	if(idRequisito!=null){
    		Criteria crit2 = criteria.createCriteria("requisito");
    		crit2.add(Restrictions.like("idRequisito",idRequisito));    		
		}		
    	if(destino!=null){
    		Criteria crit2 = criteria.createCriteria("requisito1");
    		crit2.add(Restrictions.like("idRequisito",destino));    		
		}	
		Relacionrequisito requisitos = (Relacionrequisito) criteria.uniqueResult();
		
        session.getTransaction().commit();
        logger.info("Devolviendo:"+requisitos+" encontrados");
        return requisitos;
    }
    public void create(Relacionrequisito relacionrequisito) throws PreexistingEntityException, Exception {
        if (relacionrequisito.getRelacionrequisitoPK() == null) {
            relacionrequisito.setRelacionrequisitoPK(new RelacionrequisitoPK());
        }
        relacionrequisito.getRelacionrequisitoPK().setIdTiposDeRelacion(relacionrequisito.getTiposderelacion().getIdTiposDeRelacion());
        relacionrequisito.getRelacionrequisitoPK().setRequisitoorigen(relacionrequisito.getRequisito1().getIdRequisito());
        relacionrequisito.getRelacionrequisitoPK().setRequisitodestino(relacionrequisito.getRequisito().getIdRequisito());
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Requisito requisito = relacionrequisito.getRequisito();
            if (requisito != null) {
                requisito = em.getReference(requisito.getClass(), requisito.getIdRequisito());
                relacionrequisito.setRequisito(requisito);
            }
            Requisito requisito1 = relacionrequisito.getRequisito1();
            if (requisito1 != null) {
                requisito1 = em.getReference(requisito1.getClass(), requisito1.getIdRequisito());
                relacionrequisito.setRequisito1(requisito1);
            }
            Tiposderelacion tiposderelacion = relacionrequisito.getTiposderelacion();
            if (tiposderelacion != null) {
                tiposderelacion = em.getReference(tiposderelacion.getClass(), tiposderelacion.getIdTiposDeRelacion());
                relacionrequisito.setTiposderelacion(tiposderelacion);
            }
            em.persist(relacionrequisito);
            if (requisito != null) {
                requisito.getRelacionrequisitoList().add(relacionrequisito);
                requisito = em.merge(requisito);
            }
            if (requisito1 != null) {
                requisito1.getRelacionrequisitoList().add(relacionrequisito);
                requisito1 = em.merge(requisito1);
            }
            if (tiposderelacion != null) {
                tiposderelacion.getRelacionrequisitoList().add(relacionrequisito);
                tiposderelacion = em.merge(tiposderelacion);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findRelacionrequisito(relacionrequisito.getRelacionrequisitoPK()) != null) {
                throw new PreexistingEntityException("Relacionrequisito " + relacionrequisito + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#edit(org.osiris.persistence.Relacionrequisito)
	 */
    public void edit(Relacionrequisito relacionrequisito) throws NonexistentEntityException, Exception {
        relacionrequisito.getRelacionrequisitoPK().setIdTiposDeRelacion(relacionrequisito.getTiposderelacion().getIdTiposDeRelacion());
        relacionrequisito.getRelacionrequisitoPK().setRequisitoorigen(relacionrequisito.getRequisito1().getIdRequisito());
        relacionrequisito.getRelacionrequisitoPK().setRequisitodestino(relacionrequisito.getRequisito().getIdRequisito());
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Relacionrequisito persistentRelacionrequisito = em.find(Relacionrequisito.class, relacionrequisito.getRelacionrequisitoPK());
            Requisito requisitoOld = persistentRelacionrequisito.getRequisito();
            Requisito requisitoNew = relacionrequisito.getRequisito();
            Requisito requisito1Old = persistentRelacionrequisito.getRequisito1();
            Requisito requisito1New = relacionrequisito.getRequisito1();
            Tiposderelacion tiposderelacionOld = persistentRelacionrequisito.getTiposderelacion();
            Tiposderelacion tiposderelacionNew = relacionrequisito.getTiposderelacion();
            if (requisitoNew != null) {
                requisitoNew = em.getReference(requisitoNew.getClass(), requisitoNew.getIdRequisito());
                relacionrequisito.setRequisito(requisitoNew);
            }
            if (requisito1New != null) {
                requisito1New = em.getReference(requisito1New.getClass(), requisito1New.getIdRequisito());
                relacionrequisito.setRequisito1(requisito1New);
            }
            if (tiposderelacionNew != null) {
                tiposderelacionNew = em.getReference(tiposderelacionNew.getClass(), tiposderelacionNew.getIdTiposDeRelacion());
                relacionrequisito.setTiposderelacion(tiposderelacionNew);
            }
            relacionrequisito = em.merge(relacionrequisito);
            if (requisitoOld != null && !requisitoOld.equals(requisitoNew)) {
                requisitoOld.getRelacionrequisitoList().remove(relacionrequisito);
                requisitoOld = em.merge(requisitoOld);
            }
            if (requisitoNew != null && !requisitoNew.equals(requisitoOld)) {
                requisitoNew.getRelacionrequisitoList().add(relacionrequisito);
                requisitoNew = em.merge(requisitoNew);
            }
            if (requisito1Old != null && !requisito1Old.equals(requisito1New)) {
                requisito1Old.getRelacionrequisitoList().remove(relacionrequisito);
                requisito1Old = em.merge(requisito1Old);
            }
            if (requisito1New != null && !requisito1New.equals(requisito1Old)) {
                requisito1New.getRelacionrequisitoList().add(relacionrequisito);
                requisito1New = em.merge(requisito1New);
            }
            if (tiposderelacionOld != null && !tiposderelacionOld.equals(tiposderelacionNew)) {
                tiposderelacionOld.getRelacionrequisitoList().remove(relacionrequisito);
                tiposderelacionOld = em.merge(tiposderelacionOld);
            }
            if (tiposderelacionNew != null && !tiposderelacionNew.equals(tiposderelacionOld)) {
                tiposderelacionNew.getRelacionrequisitoList().add(relacionrequisito);
                tiposderelacionNew = em.merge(tiposderelacionNew);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                RelacionrequisitoPK id = relacionrequisito.getRelacionrequisitoPK();
                if (findRelacionrequisito(id) == null) {
                    throw new NonexistentEntityException("The relacionrequisito with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#destroy(org.osiris.persistence.RelacionrequisitoPK)
	 */
    public void destroy(RelacionrequisitoPK id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Relacionrequisito relacionrequisito;
            try {
                relacionrequisito = em.getReference(Relacionrequisito.class, id);
                relacionrequisito.getRelacionrequisitoPK();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The relacionrequisito with id " + id + " no longer exists.", enfe);
            }
            Requisito requisito = relacionrequisito.getRequisito();
            if (requisito != null) {
                requisito.getRelacionrequisitoList().remove(relacionrequisito);
                requisito = em.merge(requisito);
            }
            Requisito requisito1 = relacionrequisito.getRequisito1();
            if (requisito1 != null) {
                requisito1.getRelacionrequisitoList().remove(relacionrequisito);
                requisito1 = em.merge(requisito1);
            }
            Tiposderelacion tiposderelacion = relacionrequisito.getTiposderelacion();
            if (tiposderelacion != null) {
                tiposderelacion.getRelacionrequisitoList().remove(relacionrequisito);
                tiposderelacion = em.merge(tiposderelacion);
            }
            em.remove(relacionrequisito);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#findRelacionrequisitoEntities()
	 */
    public List<Relacionrequisito> findRelacionrequisitoEntities() {
        return findRelacionrequisitoEntities(true, -1, -1);
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#findRelacionrequisitoEntities(int, int)
	 */
    public List<Relacionrequisito> findRelacionrequisitoEntities(int maxResults, int firstResult) {
        return findRelacionrequisitoEntities(false, maxResults, firstResult);
    }

    private List<Relacionrequisito> findRelacionrequisitoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Relacionrequisito as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#findRelacionrequisito(org.osiris.persistence.RelacionrequisitoPK)
	 */
    public Relacionrequisito findRelacionrequisito(RelacionrequisitoPK id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Relacionrequisito.class, id);
        } finally {
            em.close();
        }
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.impl.ReclacionRequisitoInterface#getRelacionrequisitoCount()
	 */
    public int getRelacionrequisitoCount() {
        EntityManager em = getEntityManager();
        try {
            return ((Long) em.createQuery("select count(o) from Relacionrequisito as o").getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
